import logging
import os
import json
import time
import requests
from typing import Dict, List, Any, Optional
from .base_processor import BaseProcessor

class SummaryProcessor(BaseProcessor):
    """
    摘要处理器，使用LLM API生成摘要
    """
    
    def __init__(self, config: Dict[str, Any] = None):
        """
        初始化摘要处理器
        
        Args:
            config: 处理器配置
        """
        super().__init__(config)
        # LLM配置
        self.llm_config = self.config.get('llm', {})
        self.default_provider = self.llm_config.get('default', 'deepseek')
        
        # 加载环境变量中的API密钥
        self.api_keys = {}
        for provider, provider_config in self.llm_config.get('providers', {}).items():
            api_key_var = provider_config.get('api_key', '')
            if api_key_var.startswith('${') and api_key_var.endswith('}'):
                env_var = api_key_var[2:-1]
                api_key = os.environ.get(env_var)
                if api_key:
                    self.api_keys[provider] = api_key
                else:
                    self.logger.warning(f"API key for {provider} not found in environment variable {env_var}")
        
        if not self.api_keys:
            self.logger.warning("No API keys found for any LLM provider")
    
    def process(self, data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """
        处理数据，为每项生成摘要
        
        Args:
            data: 要处理的数据列表
            
        Returns:
            处理后的数据列表
        """
        # 过滤无效数据
        valid_data = self.filter_invalid(data)
        
        processed_data = []
        for item in valid_data:
            try:
                # 如果已有摘要且不为空，跳过
                if item.get('summary') and len(item.get('summary', '').strip()) > 50:
                    processed_data.append(item)
                    continue
                
                # 根据项目类型选择不同的摘要生成策略
                item_type = item.get('type', 'unknown')
                
                if item_type == 'paper':
                    # 论文摘要处理
                    summary = self._generate_paper_summary(item)
                    keywords = self._extract_keywords(item)
                    item['summary'] = summary
                    item['keywords'] = keywords
                elif item_type == 'company_news':
                    # 公司新闻摘要处理
                    summary = self._generate_news_summary(item)
                    keywords = self._extract_keywords(item)
                    item['summary'] = summary
                    item['keywords'] = keywords
                else:
                    # 默认摘要处理
                    summary = self._generate_general_summary(item)
                    keywords = self._extract_keywords(item)
                    item['summary'] = summary
                    item['keywords'] = keywords
                
                # 添加元数据
                self.add_metadata(item)
                processed_data.append(item)
                
                # 添加延迟，避免API请求过于频繁
                time.sleep(0.5)
                
            except Exception as e:
                self.logger.error(f"Error processing item {item.get('id', 'unknown')}: {str(e)}")
                # 添加原始项目，确保数据不丢失
                processed_data.append(item)
        
        self.logger.info(f"Processed {len(processed_data)} items")
        return processed_data
    
    def _generate_paper_summary(self, paper: Dict[str, Any]) -> str:
        """
        生成论文摘要
        
        Args:
            paper: 论文数据
            
        Returns:
            生成的摘要
        """
        title = paper.get('title', '')
        abstract = paper.get('abstract', '')
        
        # 如果摘要已存在且合适，直接使用
        if abstract and len(abstract) >= 100 and len(abstract) <= 1000:
            return abstract
            
        # 构造提示词
        prompt = f"""请用中文简明扼要地总结以下AI领域学术论文的关键发现、方法和贡献(150-300字)：

标题: {title}

摘要: {abstract}

请确保你的总结：
1. 包含论文的主要创新点
2. 说明论文的方法和技术路线
3. 强调论文的实际应用价值
4. 不要使用过于专业的术语，保持通俗易懂
"""
        
        # 调用LLM API
        summary = self._call_llm_api(prompt)
        return summary or abstract
    
    def _generate_news_summary(self, news: Dict[str, Any]) -> str:
        """
        生成新闻摘要
        
        Args:
            news: 新闻数据
            
        Returns:
            生成的摘要
        """
        title = news.get('title', '')
        content = news.get('content', '')
        summary = news.get('summary', '')
        
        # 如果已有摘要且合适，直接使用
        if summary and len(summary) >= 50 and len(summary) <= 300:
            return summary
            
        # 使用内容生成摘要，如果内容过长，截取前1500个字符
        text_to_summarize = content[:1500] if content else title
        
        # 构造提示词
        prompt = f"""请用中文简明扼要地总结以下AI公司新闻的要点(100-200字)：

标题: {title}

内容: {text_to_summarize}

请确保你的总结：
1. 强调新闻的核心信息和关键点
2. 提取公司的产品、技术或战略动向
3. 说明可能对AI行业产生的影响
4. 使用客观准确的语言
"""
        
        # 调用LLM API
        summary = self._call_llm_api(prompt)
        return summary or (summary if summary else title)
    
    def _generate_general_summary(self, item: Dict[str, Any]) -> str:
        """
        生成通用摘要
        
        Args:
            item: 数据项
            
        Returns:
            生成的摘要
        """
        title = item.get('title', '')
        content = item.get('content', '')
        summary = item.get('summary', '')
        
        # 如果已有摘要且合适，直接使用
        if summary and len(summary) >= 50:
            return summary
            
        # 使用内容生成摘要，如果内容过长，截取前1000个字符
        text_to_summarize = content[:1000] if content else title
        
        # 构造提示词
        prompt = f"""请用中文简明扼要地总结以下AI技术相关内容的要点(100-200字)：

标题: {title}

内容: {text_to_summarize}

请确保你的总结：
1. 突出内容的关键信息和主要观点
2. 使用客观准确的语言
3. 保持简洁明了
"""
        
        # 调用LLM API
        summary = self._call_llm_api(prompt)
        return summary or title
    
    def _extract_keywords(self, item: Dict[str, Any]) -> List[str]:
        """
        提取关键词
        
        Args:
            item: 数据项
            
        Returns:
            关键词列表
        """
        title = item.get('title', '')
        content = item.get('abstract', '') or item.get('content', '') or item.get('summary', '')
        
        # 构造提示词
        prompt = f"""请从以下AI技术相关内容中提取5-8个关键词，只返回逗号分隔的关键词列表：

标题: {title}

内容: {content[:500]}

关键词(只返回逗号分隔的关键词，不要编号或其他格式)："""
        
        # 调用LLM API
        keywords_text = self._call_llm_api(prompt)
        
        # 解析关键词
        if keywords_text:
            # 清理并分割关键词
            keywords = [kw.strip() for kw in keywords_text.split(',')]
            # 过滤空关键词
            keywords = [kw for kw in keywords if kw]
            return keywords
        
        return []
    
    def _call_llm_api(self, prompt: str, provider: Optional[str] = None) -> Optional[str]:
        """
        调用LLM API
        
        Args:
            prompt: 提示词
            provider: LLM提供商，为None则使用默认提供商
            
        Returns:
            API返回的文本，失败返回None
        """
        provider = provider or self.default_provider
        
        if provider not in self.api_keys:
            self.logger.error(f"API key not found for provider {provider}")
            return None
        
        api_key = self.api_keys[provider]
        provider_config = self.llm_config.get('providers', {}).get(provider, {})
        base_url = provider_config.get('base_url', '')
        model = provider_config.get('model', '')
        
        if not base_url or not model:
            self.logger.error(f"Invalid configuration for provider {provider}")
            return None
        
        try:
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {api_key}"
            }
            
            payload = {
                "model": model,
                "messages": [
                    {"role": "system", "content": "你是一个专业的AI技术内容摘要助手。请提供简明扼要、客观准确的摘要。"},
                    {"role": "user", "content": prompt}
                ],
                "temperature": 0.3,
                "max_tokens": 500
            }
            
            response = requests.post(
                f"{base_url}/chat/completions", 
                headers=headers, 
                json=payload,
                timeout=30
            )
            
            if response.status_code == 200:
                result = response.json()
                # 解析不同提供商的响应
                if provider == "openai":
                    return result.get("choices", [{}])[0].get("message", {}).get("content", "")
                elif provider == "deepseek":
                    return result.get("choices", [{}])[0].get("message", {}).get("content", "")
                else:
                    return result.get("choices", [{}])[0].get("message", {}).get("content", "")
            else:
                self.logger.error(f"API error: {response.status_code} {response.text}")
                return None
        
        except Exception as e:
            self.logger.error(f"Error calling LLM API: {str(e)}")
            return None 